﻿#pragma warning disable CS8601
#pragma warning disable CS8618
#pragma warning disable CS8632

using System;
using Microsoft.Extensions.Logging;
using Unity.Logger.Entries;

using Unity.String;

namespace Unity.Logger
{
    #pragma warning disable S4136
    public static partial class LogExtensions
    {
        public static void UnityLog<T1>(this ILogger logger, LogLevel logLevel, string format, T1 arg1)
        {
            UnityLog<T1>(logger, logLevel, default, null, format, arg1);
        }

        public static void UnityLog<T1>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, logLevel, eventId, null, format, arg1);
        }

        public static void UnityLog<T1>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, logLevel, default, exception, format, arg1);
        }

        public static void UnityLog<T1>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1>(null, format, arg1), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, logLevel, default, null, payload, format, arg1);
        }

        public static void UnityLogWithPayload<TPayload, T1>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, logLevel, eventId, null, payload, format, arg1);
        }

        public static void UnityLogWithPayload<TPayload, T1>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, logLevel, default, exception, payload, format, arg1);
        }

        public static void UnityLogWithPayload<TPayload, T1>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1>(payload, format, arg1), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1);
            });
        }

        public static void UnityLogTrace<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Trace, default, null, format, arg1);
        }

        public static void UnityLogTrace<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Trace, eventId, null, format, arg1);
        }

        public static void UnityLogTrace<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Trace, default, exception, format, arg1);
        }

        public static void UnityLogTrace<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Trace, eventId, exception, format, arg1);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Trace, default, null, payload, format, arg1);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Trace, eventId, null, payload, format, arg1);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Trace, default, exception, payload, format, arg1);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1);
        }

        public static void UnityLogDebug<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Debug, default, null, format, arg1);
        }

        public static void UnityLogDebug<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Debug, eventId, null, format, arg1);
        }

        public static void UnityLogDebug<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Debug, default, exception, format, arg1);
        }

        public static void UnityLogDebug<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Debug, eventId, exception, format, arg1);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Debug, default, null, payload, format, arg1);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Debug, eventId, null, payload, format, arg1);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Debug, default, exception, payload, format, arg1);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1);
        }

        public static void UnityLogInformation<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Information, default, null, format, arg1);
        }

        public static void UnityLogInformation<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Information, eventId, null, format, arg1);
        }

        public static void UnityLogInformation<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Information, default, exception, format, arg1);
        }

        public static void UnityLogInformation<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Information, eventId, exception, format, arg1);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Information, default, null, payload, format, arg1);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Information, eventId, null, payload, format, arg1);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Information, default, exception, payload, format, arg1);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Information, eventId, exception, payload, format, arg1);
        }

        public static void UnityLogWarning<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Warning, default, null, format, arg1);
        }

        public static void UnityLogWarning<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Warning, eventId, null, format, arg1);
        }

        public static void UnityLogWarning<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Warning, default, exception, format, arg1);
        }

        public static void UnityLogWarning<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Warning, eventId, exception, format, arg1);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Warning, default, null, payload, format, arg1);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Warning, eventId, null, payload, format, arg1);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Warning, default, exception, payload, format, arg1);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1);
        }

        public static void UnityLogError<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Error, default, null, format, arg1);
        }

        public static void UnityLogError<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Error, eventId, null, format, arg1);
        }

        public static void UnityLogError<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Error, default, exception, format, arg1);
        }

        public static void UnityLogError<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Error, eventId, exception, format, arg1);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Error, default, null, payload, format, arg1);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Error, eventId, null, payload, format, arg1);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Error, default, exception, payload, format, arg1);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Error, eventId, exception, payload, format, arg1);
        }

        public static void UnityLogCritical<T1>(this ILogger logger, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Critical, default, null, format, arg1);
        }

        public static void UnityLogCritical<T1>(this ILogger logger, EventId eventId, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Critical, eventId, null, format, arg1);
        }

        public static void UnityLogCritical<T1>(this ILogger logger, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Critical, default, exception, format, arg1);
        }

        public static void UnityLogCritical<T1>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1)
        {
            UnityLog<T1>(logger, LogLevel.Critical, eventId, exception, format, arg1);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1>(this ILogger logger, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Critical, default, null, payload, format, arg1);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Critical, eventId, null, payload, format, arg1);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Critical, default, exception, payload, format, arg1);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1)
        {
            UnityLogWithPayload<TPayload, T1>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1);
        }


        public static void UnityLog<T1, T2>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, logLevel, default, null, format, arg1, arg2);
        }

        public static void UnityLog<T1, T2>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, logLevel, eventId, null, format, arg1, arg2);
        }

        public static void UnityLog<T1, T2>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, logLevel, default, exception, format, arg1, arg2);
        }

        public static void UnityLog<T1, T2>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2>(null, format, arg1, arg2), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, logLevel, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, logLevel, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, logLevel, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2>(payload, format, arg1, arg2), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2);
            });
        }

        public static void UnityLogTrace<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Trace, default, null, format, arg1, arg2);
        }

        public static void UnityLogTrace<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogTrace<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Trace, default, exception, format, arg1, arg2);
        }

        public static void UnityLogTrace<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogDebug<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Debug, default, null, format, arg1, arg2);
        }

        public static void UnityLogDebug<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogDebug<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Debug, default, exception, format, arg1, arg2);
        }

        public static void UnityLogDebug<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogInformation<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Information, default, null, format, arg1, arg2);
        }

        public static void UnityLogInformation<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Information, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogInformation<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Information, default, exception, format, arg1, arg2);
        }

        public static void UnityLogInformation<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogWarning<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Warning, default, null, format, arg1, arg2);
        }

        public static void UnityLogWarning<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogWarning<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Warning, default, exception, format, arg1, arg2);
        }

        public static void UnityLogWarning<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogError<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Error, default, null, format, arg1, arg2);
        }

        public static void UnityLogError<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Error, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogError<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Error, default, exception, format, arg1, arg2);
        }

        public static void UnityLogError<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogCritical<T1, T2>(this ILogger logger, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Critical, default, null, format, arg1, arg2);
        }

        public static void UnityLogCritical<T1, T2>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2);
        }

        public static void UnityLogCritical<T1, T2>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Critical, default, exception, format, arg1, arg2);
        }

        public static void UnityLogCritical<T1, T2>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2)
        {
            UnityLog<T1, T2>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2)
        {
            UnityLogWithPayload<TPayload, T1, T2>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2);
        }


        public static void UnityLog<T1, T2, T3>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, logLevel, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLog<T1, T2, T3>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, logLevel, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLog<T1, T2, T3>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, logLevel, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLog<T1, T2, T3>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3>(null, format, arg1, arg2, arg3), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3>(payload, format, arg1, arg2, arg3), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3);
            });
        }

        public static void UnityLogTrace<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogTrace<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogTrace<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogTrace<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebug<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebug<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebug<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebug<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformation<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformation<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformation<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformation<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarning<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarning<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarning<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarning<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogError<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogError<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogError<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogError<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogCritical<T1, T2, T3>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogCritical<T1, T2, T3>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3);
        }

        public static void UnityLogCritical<T1, T2, T3>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogCritical<T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLog<T1, T2, T3>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3);
        }


        public static void UnityLog<T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLog<T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLog<T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLog<T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4>(null, format, arg1, arg2, arg3, arg4), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4>(payload, format, arg1, arg2, arg3, arg4), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTrace<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTrace<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTrace<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebug<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebug<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebug<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebug<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformation<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformation<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformation<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformation<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarning<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarning<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarning<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarning<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogError<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogError<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogError<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogError<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCritical<T1, T2, T3, T4>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCritical<T1, T2, T3, T4>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCritical<T1, T2, T3, T4>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCritical<T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLog<T1, T2, T3, T4>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4);
        }


        public static void UnityLog<T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLog<T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLog<T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLog<T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5>(null, format, arg1, arg2, arg3, arg4, arg5), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5>(payload, format, arg1, arg2, arg3, arg4, arg5), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLog<T1, T2, T3, T4, T5>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6>(null, format, arg1, arg2, arg3, arg4, arg5, arg6), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLog<T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12, state.Arg13);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12, state.Arg13);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
        }


        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            logger.Log(logLevel, eventId, new FormatLogState<object, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12, state.Arg13, state.Arg14);
            });
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, logLevel, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            logger.Log(logLevel, eventId, new FormatLogState<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14), exception, (state, ex) =>
            {
                return UnityString.Format(state.Format, state.Arg1, state.Arg2, state.Arg3, state.Arg4, state.Arg5, state.Arg6, state.Arg7, state.Arg8, state.Arg9, state.Arg10, state.Arg11, state.Arg12, state.Arg13, state.Arg14);
            });
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTrace<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogTraceWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Trace, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebug<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogDebugWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Debug, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformation<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogInformationWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Information, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarning<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogWarningWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Warning, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogError<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogErrorWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Error, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, default, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, eventId, null, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, default, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCritical<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLog<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, eventId, exception, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, default, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, eventId, null, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, default, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }

        public static void UnityLogCriticalWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
        {
            UnityLogWithPayload<TPayload, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(logger, LogLevel.Critical, eventId, exception, payload, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
        }


        public static void UnityLog(this ILogger logger, LogLevel logLevel, string message)
        {
            UnityLog(logger, logLevel, default(EventId), default(Exception), message);
        }

        public static void UnityLog(this ILogger logger, LogLevel logLevel, EventId eventId, string message)
        {
            UnityLog(logger, logLevel, eventId, default(Exception), message);
        }

        public static void UnityLog(this ILogger logger, LogLevel logLevel, Exception? exception, string message)
        {
            UnityLog(logger, logLevel, default(EventId), exception, message);
        }

        public static void UnityLog(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string message)
        {
            logger.Log(logLevel, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogWithPayload<TPayload>(this ILogger logger, LogLevel logLevel, TPayload payload, string message)
        {
            UnityLogWithPayload<TPayload>(logger, logLevel, default, null, payload, message);
        }

        public static void UnityLogWithPayload<TPayload>(this ILogger logger, LogLevel logLevel, EventId eventId, TPayload payload, string message)
        {
            UnityLogWithPayload<TPayload>(logger, logLevel, eventId, null, payload, message);
        }

        public static void UnityLogWithPayload<TPayload>(this ILogger logger, LogLevel logLevel, Exception? exception, TPayload payload, string message)
        {
            UnityLogWithPayload<TPayload>(logger, logLevel, default, exception, payload, message);
        }

        public static void UnityLogWithPayload<TPayload>(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(logLevel, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogTrace(this ILogger logger, string message)
        {
            UnityLogTrace(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogTrace(this ILogger logger, EventId eventId, string message)
        {
            UnityLogTrace(logger, eventId, default(Exception), message);
        }

        public static void UnityLogTrace(this ILogger logger, Exception? exception, string message)
        {
            UnityLogTrace(logger, default(EventId), exception, message);
        }

        public static void UnityLogTrace(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Trace, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogTraceWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogTraceWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogTraceWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogTraceWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogTraceWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogTraceWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogTraceWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Trace, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogDebug(this ILogger logger, string message)
        {
            UnityLogDebug(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogDebug(this ILogger logger, EventId eventId, string message)
        {
            UnityLogDebug(logger, eventId, default(Exception), message);
        }

        public static void UnityLogDebug(this ILogger logger, Exception? exception, string message)
        {
            UnityLogDebug(logger, default(EventId), exception, message);
        }

        public static void UnityLogDebug(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Debug, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogDebugWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogDebugWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogDebugWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogDebugWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogDebugWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogDebugWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogDebugWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Debug, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogInformation(this ILogger logger, string message)
        {
            UnityLogInformation(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogInformation(this ILogger logger, EventId eventId, string message)
        {
            UnityLogInformation(logger, eventId, default(Exception), message);
        }

        public static void UnityLogInformation(this ILogger logger, Exception? exception, string message)
        {
            UnityLogInformation(logger, default(EventId), exception, message);
        }

        public static void UnityLogInformation(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Information, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogInformationWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogInformationWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogInformationWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogInformationWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogInformationWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogInformationWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogInformationWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Information, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogWarning(this ILogger logger, string message)
        {
            UnityLogWarning(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogWarning(this ILogger logger, EventId eventId, string message)
        {
            UnityLogWarning(logger, eventId, default(Exception), message);
        }

        public static void UnityLogWarning(this ILogger logger, Exception? exception, string message)
        {
            UnityLogWarning(logger, default(EventId), exception, message);
        }

        public static void UnityLogWarning(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Warning, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogWarningWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogWarningWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogWarningWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogWarningWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogWarningWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogWarningWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogWarningWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Warning, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogError(this ILogger logger, string message)
        {
            UnityLogError(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogError(this ILogger logger, EventId eventId, string message)
        {
            UnityLogError(logger, eventId, default(Exception), message);
        }

        public static void UnityLogError(this ILogger logger, Exception? exception, string message)
        {
            UnityLogError(logger, default(EventId), exception, message);
        }

        public static void UnityLogError(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Error, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogErrorWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogErrorWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogErrorWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogErrorWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogErrorWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogErrorWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogErrorWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Error, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogCritical(this ILogger logger, string message)
        {
            UnityLogCritical(logger, default(EventId), default(Exception), message);
        }

        public static void UnityLogCritical(this ILogger logger, EventId eventId, string message)
        {
            UnityLogCritical(logger, eventId, default(Exception), message);
        }

        public static void UnityLogCritical(this ILogger logger, Exception? exception, string message)
        {
            UnityLogCritical(logger, default(EventId), exception, message);
        }

        public static void UnityLogCritical(this ILogger logger, EventId eventId, Exception? exception, string message)
        {
            logger.Log(LogLevel.Critical, eventId, new MessageLogState<object>(null, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }

        public static void UnityLogCriticalWithPayload<TPayload>(this ILogger logger, TPayload payload, string message)
        {
            UnityLogCriticalWithPayload<TPayload>(logger, default, null, payload, message);
        }

        public static void UnityLogCriticalWithPayload<TPayload>(this ILogger logger, EventId eventId, TPayload payload, string message)
        {
            UnityLogCriticalWithPayload<TPayload>(logger, eventId, null, payload, message);
        }

        public static void UnityLogCriticalWithPayload<TPayload>(this ILogger logger, Exception? exception, TPayload payload, string message)
        {
            UnityLogCriticalWithPayload<TPayload>(logger, default, exception, payload, message);
        }

        public static void UnityLogCriticalWithPayload<TPayload>(this ILogger logger, EventId eventId, Exception? exception, TPayload payload, string message)
        {
            logger.Log(LogLevel.Critical, eventId, new MessageLogState<TPayload>(payload, message), exception, (state, ex) =>
            {
                return state.Message;
            });
        }
    }
    #pragma warning restore S4136
}
